#ifndef _Arithmetic_h
#define _Arithmetic_h

#include "CxxUtils.h"
#include "LangUtils.h"

class DoOpArithmetic
{
public: 
	class ds_add : public _DoOperator
	{
	protected: 
		ds_add(const ds_add &);
		ds_add& operator=(const ds_add &);
	public: 
		ds_add() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_div : public _DoOperator
	{
	protected: 
		ds_div(const ds_div &);
		ds_div& operator=(const ds_div &);
	public: 
		ds_div() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_idiv : public _DoOperator
	{
	protected: 
		ds_idiv(const ds_idiv &);
		ds_idiv& operator=(const ds_idiv &);
	public: 
		ds_idiv() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_mod : public _DoOperator
	{
	protected: 
		ds_mod(const ds_mod &);
		ds_mod& operator=(const ds_mod &);
	public: 
		ds_mod() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_mul : public _DoOperator
	{
	protected: 
		ds_mul(const ds_mul &);
		ds_mul& operator=(const ds_mul &);
	public: 
		ds_mul() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_sub : public _DoOperator
	{
	protected: 
		ds_sub(const ds_sub &);
		ds_sub& operator=(const ds_sub &);
	public: 
		ds_sub() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_abs : public _DoOperator
	{
	protected: 
		ds_abs(const ds_abs &);
		ds_abs& operator=(const ds_abs &);
	public: 
		ds_abs() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_neg : public _DoOperator
	{
	protected: 
		ds_neg(const ds_neg &);
		ds_neg& operator=(const ds_neg &);
	public: 
		ds_neg() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_ceiling : public _DoOperator
	{
	protected: 
		ds_ceiling(const ds_ceiling &);
		ds_ceiling& operator=(const ds_ceiling &);
	public: 
		ds_ceiling() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_floor : public _DoOperator
	{
	protected: 
		ds_floor(const ds_floor &);
		ds_floor& operator=(const ds_floor &);
	public: 
		ds_floor() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_round : public _DoOperator
	{
	protected: 
		ds_round(const ds_round &);
		ds_round& operator=(const ds_round &);
	public: 
		ds_round() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_truncate : public _DoOperator
	{
	protected: 
		ds_truncate(const ds_truncate &);
		ds_truncate& operator=(const ds_truncate &);
	public: 
		ds_truncate() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_sqrt : public _DoOperator
	{
	protected: 
		ds_sqrt(const ds_sqrt &);
		ds_sqrt& operator=(const ds_sqrt &);
	public: 
		ds_sqrt() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_atan : public _DoOperator
	{
	protected: 
		ds_atan(const ds_atan &);
		ds_atan& operator=(const ds_atan &);
	public: 
		ds_atan() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_cos : public _DoOperator
	{
	protected: 
		ds_cos(const ds_cos &);
		ds_cos& operator=(const ds_cos &);
	public: 
		ds_cos() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_sin : public _DoOperator
	{
	protected: 
		ds_sin(const ds_sin &);
		ds_sin& operator=(const ds_sin &);
	public: 
		ds_sin() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_exp : public _DoOperator
	{
	protected: 
		ds_exp(const ds_exp &);
		ds_exp& operator=(const ds_exp &);
	public: 
		ds_exp() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_ln : public _DoOperator
	{
	protected: 
		ds_ln(const ds_ln &);
		ds_ln& operator=(const ds_ln &);
	public: 
		ds_ln() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_log : public _DoOperator
	{
	protected: 
		ds_log(const ds_log &);
		ds_log& operator=(const ds_log &);
	public: 
		ds_log() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rand : public _DoOperator
	{
	protected: 
		ds_rand(const ds_rand &);
		ds_rand& operator=(const ds_rand &);
	public: 
		ds_rand() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_srand : public _DoOperator
	{
	protected: 
		ds_srand(const ds_srand &);
		ds_srand& operator=(const ds_srand &);
	public: 
		ds_srand() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_rrand : public _DoOperator
	{
	protected: 
		ds_rrand(const ds_rrand &);
		ds_rrand& operator=(const ds_rrand &);
	public: 
		ds_rrand() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	static void push(_DoDictionaryMultimap& dict) {
		dict.put(CRefPtr< _DoObject >(new DoName("add")), CRefPtr< _DoObject >(new ds_add()));
		dict.put(CRefPtr< _DoObject >(new DoName("div")), CRefPtr< _DoObject >(new ds_div()));
		dict.put(CRefPtr< _DoObject >(new DoName("idiv")), CRefPtr< _DoObject >(new ds_idiv()));
		dict.put(CRefPtr< _DoObject >(new DoName("mod")), CRefPtr< _DoObject >(new ds_mod()));
		dict.put(CRefPtr< _DoObject >(new DoName("mul")), CRefPtr< _DoObject >(new ds_mul()));
		dict.put(CRefPtr< _DoObject >(new DoName("sub")), CRefPtr< _DoObject >(new ds_sub()));
		dict.put(CRefPtr< _DoObject >(new DoName("abs")), CRefPtr< _DoObject >(new ds_abs()));
		dict.put(CRefPtr< _DoObject >(new DoName("neg")), CRefPtr< _DoObject >(new ds_neg()));
		dict.put(CRefPtr< _DoObject >(new DoName("ceiling")), CRefPtr< _DoObject >(new ds_ceiling()));
		dict.put(CRefPtr< _DoObject >(new DoName("floor")), CRefPtr< _DoObject >(new ds_floor()));
		dict.put(CRefPtr< _DoObject >(new DoName("round")), CRefPtr< _DoObject >(new ds_round()));
		dict.put(CRefPtr< _DoObject >(new DoName("truncate")), CRefPtr< _DoObject >(new ds_truncate()));
		dict.put(CRefPtr< _DoObject >(new DoName("sqrt")), CRefPtr< _DoObject >(new ds_sqrt()));
		dict.put(CRefPtr< _DoObject >(new DoName("atan")), CRefPtr< _DoObject >(new ds_atan()));
		dict.put(CRefPtr< _DoObject >(new DoName("cos")), CRefPtr< _DoObject >(new ds_cos()));
		dict.put(CRefPtr< _DoObject >(new DoName("sin")), CRefPtr< _DoObject >(new ds_sin()));
		dict.put(CRefPtr< _DoObject >(new DoName("exp")), CRefPtr< _DoObject >(new ds_exp()));
		dict.put(CRefPtr< _DoObject >(new DoName("ln")), CRefPtr< _DoObject >(new ds_ln()));
		dict.put(CRefPtr< _DoObject >(new DoName("log")), CRefPtr< _DoObject >(new ds_log()));
		dict.put(CRefPtr< _DoObject >(new DoName("rand")), CRefPtr< _DoObject >(new ds_rand()));
		dict.put(CRefPtr< _DoObject >(new DoName("srand")), CRefPtr< _DoObject >(new ds_srand()));
		dict.put(CRefPtr< _DoObject >(new DoName("rrand")), CRefPtr< _DoObject >(new ds_rrand()));
	}
};

#endif
